* Guile 3 and Guile 2.2.x

Guile 3 has introduced new ways of handling exceptions, which might be
preferable to how it was done in Guile 2.2.x. This is the reason for there being
separate examples.

* To do [0/1]

- [-] work in the feedback / improvement suggestions from the Guile users mailing list [1/2]

  - [ ] consider the impact of the "non-continuable exceptions" concept

    Apparently "non-continuable exceptions" does not mean, that the program must
    exit or cannot continue, but rather, that the control flow cannot continue at
    the point, where the exception was raised. This has implications for the code
    in the example.

    1. [ ] In case of "non-continuable" exceptions the handler procedure given to
       ~with-exception-handler~ should not return. If it returns, then another
       "non-continuable" exception will be raised when it tries to return.

       Q: I do not understand why it works this way yet. Why would another
       non-continuable exception be raised?

    2. [ ] For ~with-exception-handler~ from R6RS or R7RS the handler procedure is
       supposed to do one or more the following things:

       1. Do some exception handling actions.

       2. Call a ~call/ec~ "continuation object".

          - Guile 3's ~with-exception-handler~ does this automatically, if the
            ~#:unwind?~ keyword argument is set to ~#t~.

            - This is the most similar to Guile 2.2's ~catch~ expression.

            - R6RS's or R7RS's ~guard~ expression is a wrapper around
              ~with-exception-handler~ with ~#:unwind?~ set to ~#t~.

              - ~guard~ also allows for a ~cond~ expression, which enables to
                specify different handlers for different exception.

       3. Re-raise the exception.

       4. Q: What is a ~call/ec~ continuation object? An object, which is a
       continuation, captured previously?

       - Q: What is the difference between a ~call/cc~ (current continuation) and a
       ~call/ec~ (??? continuation) continuation object?

       - Calling a ~call/ec~ continuation object will unwind the stack.

         Q: This means going back out the stack frames or throwing the stack
         frames away?

       - The stack will be unwound until a point is reached, where there is a
         handler for the exception.

  - [X] Improvement suggestions

    - [X] For Guile 2.2 and 3:

      - [X] The first example should use ~#:unwind?~ ~#t~, so that the program
        does not end in a "non-continuable" exception.

      - [X] R6RS and R7RS exception procedures can only handle R6RS or R7RS
        exceptions raised via ~raise~ or ~raise-continuable~, but not exceptions
        raised by Guile via ~throw~. The first example however will cause an
        exception raised by Guile via ~throw~. This means the first example
        should not work on Guile 2.2. --> Do not use this example in the Guile
        2.2.x version of the examples.

    - [X] For Guile 3:

      - [X] Use Guile's exception objects instead of R6RS or R7RS conditions, by
        using ~make-exception~ instead of ~condition~, which are more or less
        the same, but it expresses things in terms of Guile 3 vocabulary.

        - Q: But why is this better? Would not be ~condition~ more portable to
          other Schemes?
